home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / xdrlib.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  10.5 KB  |  359 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Implements (a subset of) Sun XDR -- eXternal Data Representation.
  5.  
  6. See: RFC 1014
  7.  
  8. '''
  9. import struct
  10.  
  11. try:
  12.     from cStringIO import StringIO as _StringIO
  13. except ImportError:
  14.     from StringIO import StringIO as _StringIO
  15.  
  16. __all__ = [
  17.     'Error',
  18.     'Packer',
  19.     'Unpacker',
  20.     'ConversionError']
  21.  
  22. class Error(Exception):
  23.     '''Exception class for this module. Use:
  24.  
  25.     except xdrlib.Error, var:
  26.         # var has the Error instance for the exception
  27.  
  28.     Public ivars:
  29.         msg -- contains the message
  30.  
  31.     '''
  32.     
  33.     def __init__(self, msg):
  34.         self.msg = msg
  35.  
  36.     
  37.     def __repr__(self):
  38.         return repr(self.msg)
  39.  
  40.     
  41.     def __str__(self):
  42.         return str(self.msg)
  43.  
  44.  
  45.  
  46. class ConversionError(Error):
  47.     pass
  48.  
  49.  
  50. class Packer:
  51.     '''Pack various data representations into a buffer.'''
  52.     
  53.     def __init__(self):
  54.         self.reset()
  55.  
  56.     
  57.     def reset(self):
  58.         self._Packer__buf = _StringIO()
  59.  
  60.     
  61.     def get_buffer(self):
  62.         return self._Packer__buf.getvalue()
  63.  
  64.     get_buf = get_buffer
  65.     
  66.     def pack_uint(self, x):
  67.         self._Packer__buf.write(struct.pack('>L', x))
  68.  
  69.     pack_int = pack_uint
  70.     pack_enum = pack_int
  71.     
  72.     def pack_bool(self, x):
  73.         if x:
  74.             self._Packer__buf.write('\x00\x00\x00\x01')
  75.         else:
  76.             self._Packer__buf.write('\x00\x00\x00\x00')
  77.  
  78.     
  79.     def pack_uhyper(self, x):
  80.         self.pack_uint(x >> 32 & 0xFFFFFFFFL)
  81.         self.pack_uint(x & 0xFFFFFFFFL)
  82.  
  83.     pack_hyper = pack_uhyper
  84.     
  85.     def pack_float(self, x):
  86.         
  87.         try:
  88.             self._Packer__buf.write(struct.pack('>f', x))
  89.         except struct.error:
  90.             msg = None
  91.             raise ConversionError, msg
  92.  
  93.  
  94.     
  95.     def pack_double(self, x):
  96.         
  97.         try:
  98.             self._Packer__buf.write(struct.pack('>d', x))
  99.         except struct.error:
  100.             msg = None
  101.             raise ConversionError, msg
  102.  
  103.  
  104.     
  105.     def pack_fstring(self, n, s):
  106.         if n < 0:
  107.             raise ValueError, 'fstring size must be nonnegative'
  108.         
  109.         n = ((n + 3) / 4) * 4
  110.         data = s[:n]
  111.         data = data + (n - len(data)) * '\x00'
  112.         self._Packer__buf.write(data)
  113.  
  114.     pack_fopaque = pack_fstring
  115.     
  116.     def pack_string(self, s):
  117.         n = len(s)
  118.         self.pack_uint(n)
  119.         self.pack_fstring(n, s)
  120.  
  121.     pack_opaque = pack_string
  122.     pack_bytes = pack_string
  123.     
  124.     def pack_list(self, list, pack_item):
  125.         for item in list:
  126.             self.pack_uint(1)
  127.             pack_item(item)
  128.         
  129.         self.pack_uint(0)
  130.  
  131.     
  132.     def pack_farray(self, n, list, pack_item):
  133.         if len(list) != n:
  134.             raise ValueError, 'wrong array size'
  135.         
  136.         for item in list:
  137.             pack_item(item)
  138.         
  139.  
  140.     
  141.     def pack_array(self, list, pack_item):
  142.         n = len(list)
  143.         self.pack_uint(n)
  144.         self.pack_farray(n, list, pack_item)
  145.  
  146.  
  147.  
  148. class Unpacker:
  149.     '''Unpacks various data representations from the given buffer.'''
  150.     
  151.     def __init__(self, data):
  152.         self.reset(data)
  153.  
  154.     
  155.     def reset(self, data):
  156.         self._Unpacker__buf = data
  157.         self._Unpacker__pos = 0
  158.  
  159.     
  160.     def get_position(self):
  161.         return self._Unpacker__pos
  162.  
  163.     
  164.     def set_position(self, position):
  165.         self._Unpacker__pos = position
  166.  
  167.     
  168.     def get_buffer(self):
  169.         return self._Unpacker__buf
  170.  
  171.     
  172.     def done(self):
  173.         if self._Unpacker__pos < len(self._Unpacker__buf):
  174.             raise Error('unextracted data remains')
  175.         
  176.  
  177.     
  178.     def unpack_uint(self):
  179.         i = self._Unpacker__pos
  180.         self._Unpacker__pos = j = i + 4
  181.         data = self._Unpacker__buf[i:j]
  182.         if len(data) < 4:
  183.             raise EOFError
  184.         
  185.         x = struct.unpack('>L', data)[0]
  186.         
  187.         try:
  188.             return int(x)
  189.         except OverflowError:
  190.             return x
  191.  
  192.  
  193.     
  194.     def unpack_int(self):
  195.         i = self._Unpacker__pos
  196.         self._Unpacker__pos = j = i + 4
  197.         data = self._Unpacker__buf[i:j]
  198.         if len(data) < 4:
  199.             raise EOFError
  200.         
  201.         return struct.unpack('>l', data)[0]
  202.  
  203.     unpack_enum = unpack_int
  204.     unpack_bool = unpack_int
  205.     
  206.     def unpack_uhyper(self):
  207.         hi = self.unpack_uint()
  208.         lo = self.unpack_uint()
  209.         return long(hi) << 32 | lo
  210.  
  211.     
  212.     def unpack_hyper(self):
  213.         x = self.unpack_uhyper()
  214.         if x >= 0x8000000000000000L:
  215.             x = x - 0x10000000000000000L
  216.         
  217.         return x
  218.  
  219.     
  220.     def unpack_float(self):
  221.         i = self._Unpacker__pos
  222.         self._Unpacker__pos = j = i + 4
  223.         data = self._Unpacker__buf[i:j]
  224.         if len(data) < 4:
  225.             raise EOFError
  226.         
  227.         return struct.unpack('>f', data)[0]
  228.  
  229.     
  230.     def unpack_double(self):
  231.         i = self._Unpacker__pos
  232.         self._Unpacker__pos = j = i + 8
  233.         data = self._Unpacker__buf[i:j]
  234.         if len(data) < 8:
  235.             raise EOFError
  236.         
  237.         return struct.unpack('>d', data)[0]
  238.  
  239.     
  240.     def unpack_fstring(self, n):
  241.         if n < 0:
  242.             raise ValueError, 'fstring size must be nonnegative'
  243.         
  244.         i = self._Unpacker__pos
  245.         j = i + ((n + 3) / 4) * 4
  246.         if j > len(self._Unpacker__buf):
  247.             raise EOFError
  248.         
  249.         self._Unpacker__pos = j
  250.         return self._Unpacker__buf[i:i + n]
  251.  
  252.     unpack_fopaque = unpack_fstring
  253.     
  254.     def unpack_string(self):
  255.         n = self.unpack_uint()
  256.         return self.unpack_fstring(n)
  257.  
  258.     unpack_opaque = unpack_string
  259.     unpack_bytes = unpack_string
  260.     
  261.     def unpack_list(self, unpack_item):
  262.         list = []
  263.         while None:
  264.             x = self.unpack_uint()
  265.             if x == 0:
  266.                 break
  267.             
  268.             if x != 1:
  269.                 raise ConversionError, '0 or 1 expected, got %r' % (x,)
  270.             
  271.             item = unpack_item()
  272.         return list
  273.  
  274.     
  275.     def unpack_farray(self, n, unpack_item):
  276.         list = []
  277.         for i in range(n):
  278.             list.append(unpack_item())
  279.         
  280.         return list
  281.  
  282.     
  283.     def unpack_array(self, unpack_item):
  284.         n = self.unpack_uint()
  285.         return self.unpack_farray(n, unpack_item)
  286.  
  287.  
  288.  
  289. def _test():
  290.     p = Packer()
  291.     packtest = [
  292.         (p.pack_uint, (9,)),
  293.         (p.pack_bool, (None,)),
  294.         (p.pack_bool, ('hello',)),
  295.         (p.pack_uhyper, (0x2DL,)),
  296.         (p.pack_float, (1.8999999999999999,)),
  297.         (p.pack_double, (1.8999999999999999,)),
  298.         (p.pack_string, ('hello world',)),
  299.         (p.pack_list, (range(5), p.pack_uint)),
  300.         (p.pack_array, ([
  301.             'what',
  302.             'is',
  303.             'hapnin',
  304.             'doctor'], p.pack_string))]
  305.     succeedlist = [
  306.         1] * len(packtest)
  307.     count = 0
  308.     for method, args in packtest:
  309.         print 'pack test', count,
  310.         
  311.         try:
  312.             method(*args)
  313.             print 'succeeded'
  314.         except ConversionError:
  315.             var = None
  316.             print 'ConversionError:', var.msg
  317.             succeedlist[count] = 0
  318.  
  319.         count = count + 1
  320.     
  321.     data = p.get_buffer()
  322.     up = Unpacker(data)
  323.     unpacktest = [
  324.         (up.unpack_uint, (), (lambda x: x == 9)),
  325.         (up.unpack_bool, (), (lambda x: not x)),
  326.         (up.unpack_bool, (), (lambda x: x)),
  327.         (up.unpack_uhyper, (), (lambda x: x == 0x2DL)),
  328.         (up.unpack_float, (), (lambda x: None if x < x else x < 1.9099999999999999)),
  329.         (up.unpack_double, (), (lambda x: None if x < x else x < 1.9099999999999999)),
  330.         (up.unpack_string, (), (lambda x: x == 'hello world')),
  331.         (up.unpack_list, (up.unpack_uint,), (lambda x: x == range(5))),
  332.         (up.unpack_array, (up.unpack_string,), (lambda x: x == [
  333. 'what',
  334. 'is',
  335. 'hapnin',
  336. 'doctor']))]
  337.     count = 0
  338.     for method, args, pred in unpacktest:
  339.         print 'unpack test', count,
  340.         
  341.         try:
  342.             if succeedlist[count]:
  343.                 x = method(*args)
  344.                 if not pred(x) or 'succeeded':
  345.                     pass
  346.                 print 'failed', ':', x
  347.             else:
  348.                 print 'skipping'
  349.         except ConversionError:
  350.             var = None
  351.             print 'ConversionError:', var.msg
  352.  
  353.         count = count + 1
  354.     
  355.  
  356. if __name__ == '__main__':
  357.     _test()
  358.  
  359.